/*
package com.tedu.api.list;

import org.junit.*;
import org.testng.annotations.Test;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;

*/
/**
 * 数组：遍历数据   遍历数据三种：普通for 增强for  Arrays工具类
 * √集合：遍历数据   遍历数据三种：普通for 增强for Iterator迭代器
 *  保存数据优选：集合-----变量数据优选Iterator迭代器
 *Iterator迭代器   接口----依赖Collection提供方法：iterator（）
 *
 * 集合：迭代器使用方式：问，取，【不是必须操作】删
 *//*

public class Collection_IteratorAPI {
    @Test
    public void testIterator(){
        Collection c1=new ArrayList();
        c1.add("one");  c1.add("tow"); c1.add("three");
        */
/**
         * iterator()方法：获取集合的迭代器---遍历数据
         *//*

        Iterator it= c1.iterator();
        //迭代器使用：1.问--集合中是否存在元素【集合元素不确定】
        */
/**
         * hasNext()   返回值：boolean
         * 作用：判断集合当中是否还有元素可以遍历，返回true有元素  返回false无元素
         *//*

        while(it.hasNext()){ //；迭代器：问操作--hasNext()
            //2.取--如果集合中存在元素：取出元素：取出元素---next（）
            */
/**
             * E  next（）     返回值：E泛型  简单理解：Object
             * 作用：遍历取出元素
             *//*

            String str=(String) it.next();
            System.out.println("集合迭代器"+str);
        }
    }
    */
/**
     * 集合三种遍历方式：Iterator迭代器【问，取操作】
     *                   普通for【难度，需要查API】
     *                   增强for【没有难度】
     *                   开发：选一种
     *                   遍历同时对集合做元素删除操作--Iterator迭代器
     *//*

    @Test
    public void testFor(){
        Collection collection=new ArrayList();
        //需求：10个元素，普通for增加元素：0-9数值
        for(int i=0;i<10;i++){
            collection.add(i);

        }
        System.out.println("打印集合数据："+collection);


        //获取集合中所有的数据--------操作
        //①使用普通for遍历 collection集合  提醒：查API
        //获取集合元素：List---方法get()
        for(int i=0;i<collection.size();i++){//拿下标
            //  collection.getClass();
            //  System.out.println("普通for输出集合："+i);   自己用的方式
            System.out.println("普通for输出集合②："+((List)collection).get(i));
        }


        //②使用增强for遍历：   语法：for（Integer i:集合名）{}
        //                         for(Object i:集合名)
        //collection是顶级集合--存任何数据--Object类型
        Collection a=new ArrayList();
        for(int i=0;i<10;i++){
            a.add(i);
        }
        for (Object i:a){
            System.out.println("使用增强for输出集合："+i);
        }
    }
    */
/**
     *   遍历同时对集合做元素删除操作--Iterator迭代器
     *   Iterator迭代器---删除操作【真删元素】
     *   remove()    返回值：void
     *   作用：删除迭代器获取的元素【理解：next（）取元素之后，删除】
     *   集合：迭代器使用方式：问，取，【不是必须操作】删
     *
     *   作业：增强for循环，删除testRemove但阿远测试中集合包含”寂寞验货“元素
     *   作业单元测试名：testHomeWork（）
     *//*

    @Test
    public void testRemove(){
        Collection a=new ArrayList();
        a.add("每当想起你时");  a.add("这世界那么多人");  a.add("总有一天我会来到我身边");
        a.add("寂寞烟火");
        //创建集合Collection---遍历同时删除春节的元素
        System.out.println("Collection集合"+a);
        //1.依赖集合Collection--提供 iterator（）方法  创建迭代器对象
        Iterator it=a.iterator();
        //2.使用迭代器：问 取 删
        while(it.hasNext()){//问：集合中是否有元素
            //3.获取集合中元素  next()  获取元素，默认类型Object
            String str=(String)it.next();
            //4.删除集合中存在”每当想起你时“
            //4.1   如果集合中元素名“每当想起你时”  删除
            if("每当想起你时".equals(str)){
                it.remove(); //next()  拿到元素之后删除操作
            }

            // a.remove("");  //集合中删除  Collection中的方法

        }
        System.out.println("迭代器实现删除元素操作："+a);
    }
    @Test
    public void testHomeWork(){
        */
/**
         * 集合：iterator 通过迭代--遍历集合-----遍历同时删除元素  【推荐】
         *      普通for  【不推荐】
         *      增强for【不可以遍历同时删除元素】
         *      ConcurrentModificationException   并发修改异常
         *      产生原因：增强for底层遍历采用iterator遍历---迭代器删除元素
         *                                      集合山元素
         *                    增强for中删除集合元素的方法用错
         *//*

        Collection<String> y=new ArrayList<>();
        y.add("每当");  y.add("过活");  y.add("突然"); y.add("失控");
        System.out.println(y);
      */
/*   Iterator<String> it=y.iterator();
         while(it.hasNext()){
             String str=it.next();
             if("失控".equals(str) ){
                 it.remove();   //迭代器 it删除  集合元素
              //  y.remove(str); //删除肯定报错   有个别元素可以删
             }

         }
        System.out.println(y); *//*

        for(String s:y){
            if("过活".equals(s)){  //元旦 判断 集合 “过活”
                y.remove("过活");          //是集合中的元旦，删除
            }
            System.out.println(s);

        }
        System.out.println(y);

    }

    */
/**
     * 泛型：与集合搭配使用       E element  元素  理解：Object
     * JDK1.5之后推出新特性，集合存任何数据，获取数据非常混乱
     *                   对象，整型，小数型  取   Object 知道类型
     *泛型主要功能是约束集合的类型!
     * 泛型编译器认可的，JVM虚拟机不认可，认为：Object对象
     * 使用泛型好处:1.约束类型，数据稳定【同一类型】，获取元素无需造型
     *            2.类型：对象---继承以及继承之后方法使用super
     *
     * 语法：Collection<类型：引用类型，包装类型> c=
     * new ArrrayList<类型：引用类型，包装类型>();
     *
     *//*

    @Test
    public void testElement(){
        //JDK1.5  泛型写法
        Collection<String> a=new ArrayList<String>();
        //JDK1.7  泛型写法   建议使用
        Collection<String> y=new ArrayList<>();
        y.add("老六");   y.add("每当");// y.add(1);
        Iterator<String> it=y.iterator();
        while (it.hasNext()) {//问  存在数据 存在true
            String str = it.next();
        }
        System.out.println(y);

        Collection<Float> a1=new ArrayList<>();
        a1.add(7.7f);
        Collection<Boolean> A2=new ArrayList<>();
        A2.add(true);

        //泛型定义：？代表：不限制类型 [没有意义--null]  项目非常大---功能
        Collection<?> a2=new ArrayList<>();
        // a2.add("字符串");  a2.add(3);  a2.add(1.1f); a2.add(new Object());
        a2.add(null);   //只能存没有意义的值：引用类型--默认值：null
    }

    */
/**
     * 泛型中通配符  ？ 【任意类型】 的使用
     * ？【任意类型】 extends 父类
     *   【任意类型：父类的所有子类】    --约束---
     *//*

    @Test
    public <Pear> void testE(){
        //测试创建集合---传入参数：引用类型  apple对象

        Collection<Apple> apples=new ArrayList<>();
        apples.add(new Apple());  //存入apple对象
        TestJob.printFruit(apples);//上界限定操作  针对集合
        Collection<Orange> o=new ArrayList<>();
        o.add(new Orange());
        TestJob.printFruit(o);
        Collection<Pear> p=new ArrayList<>();
        p.add(new Pear());
        TestJob.printFruit(p);
    }
}
*/
